.TH std::get_time 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::get_time \- std::get_time

.SH Synopsis
   Defined in header <iomanip>
   template< class CharT >                                      \fI(since C++11)\fP
   /*unspecified*/ get_time( std::tm* tmb, const CharT* fmt );

   When used in an expression in >> get_time(tmb, fmt), parses the character input as a
   date/time value according to format string fmt according to the std::time_get facet
   of the locale currently imbued in the input stream in. The resultant value is stored
   in a std::tm object pointed to by tmb.

.SH Parameters

   tmb - valid pointer to the std::tm object where the result will be stored
         pointer to a null-terminated CharT string specifying the conversion format

         The format string consists of zero or more conversion specifiers, whitespace
         characters, and ordinary characters (except %). Each ordinary character is
         expected to match one character in the input stream in case-insensitive
         comparison. Each whitespace character matches arbitrary whitespace in the
         input string. Each conversion specification begins with % character,
         optionally followed by E or O modifier (ignored if unsupported by the locale),
         followed by the character that determines the behavior of the specifier. The
         format specifiers match the POSIX function strptime():

         Conversion                    Explanation                    Writes to fields
         specifier
             %      matches a literal %. The full conversion          \fI(none)\fP
                    specification must be %%
             t      matches any whitespace                            \fI(none)\fP
             n      matches any whitespace                            \fI(none)\fP
                                              Year
             Y      parses full year as a 4 digit decimal number,     tm_year
                    leading zeroes permitted but not required
                    parses year in the alternative representation,
             EY     e.g.平成23年 (year Heisei 23) which writes 2011   tm_year
                    to tm_year in ja_JP locale
                    parses last 2 digits of year as a decimal number.
             y      Range [69,99] results in values 1969 to 1999,     tm_year
                    range [00,68] results in 2000-2068
                    parses last 2 digits of year using the
             Oy     alternative numeric system, e.g. 十一 is parsed   tm_year
                    as 11 in ja_JP locale
             Ey     parses year as offset from locale's alternative   tm_year
                    calendar period %EC
             C      parses the first 2 digits of year as a decimal    tm_year
                    number (range [00,99])
                    parses the name of the base year (period) in the
             EC     locale's alternative representation, e.g. 平成    tm_year
                    (Heisei era) in ja_JP
                                             Month
             b      parses the month name, either full or             tm_mon
                    abbreviated, e.g. Oct
             h      synonym of b                                      tm_mon
             B      synonym of b                                      tm_mon
                    parses the month as a decimal number (range
             m      [01,12]), leading zeroes permitted but not        tm_mon
                    required
             Om     parses the month using the alternative numeric    tm_mon
                    system, e.g. 十二 parses as 12 in ja_JP locale
                                              Week
                    parses the week of the year as a decimal number
             U      (Sunday is the first day of the week) (range      tm_year, tm_wday,
                    [00,53]), leading zeroes permitted but not        tm_yday
                    required
                    parses the week of the year, as by %U, using the  tm_year, tm_wday,
             OU     alternative numeric system, e.g. 五十二 parses as tm_yday
                    52 in ja_JP locale
                    parses the week of the year as a decimal number
             W      (Monday is the first day of the week) (range      tm_year, tm_wday,
                    [00,53]), leading zeroes permitted but not        tm_yday
                    required
                    parses the week of the year, as by %W, using the  tm_year, tm_wday,
             OW     alternative numeric system, e.g. 五十二 parses as tm_yday
                    52 in ja_JP locale
                                     Day of the year/month
                    parses day of the year as a decimal number (range
             j      [001,366]), leading zeroes permitted but not      tm_yday
                    required
   fmt -            parses the day of the month as a decimal number
             d      (range [01,31]), leading zeroes permitted but not tm_mday
                    required
                    parses the day of the month using the alternative
             Od     numeric system, e.g. 二十七 parses as 27 in ja_JP tm_mday
                    locale, leading zeroes permitted but not required
             e      synonym of d                                      tm_mday
             Oe     synonym of Od                                     tm_mday
                                        Day of the week
             a      parses the name of the day of the week, either    tm_wday
                    full or abbreviated, e.g. Fri
             A      synonym of a                                      tm_wday
             w      parses weekday as a decimal number, where Sunday  tm_wday
                    is 0 (range [0-6])
                    parses weekday as a decimal number, where Sunday
             Ow     is 0, using the alternative numeric system, e.g.  tm_wday
                    二 parses as 2 in ja_JP locale
                                      Hour, minute, second
                    parses the hour as a decimal number, 24 hour
             H      clock (range [00-23]), leading zeroes permitted   tm_hour
                    but not required
                    parses hour from 24-hour clock using the
             OH     alternative numeric system, e.g. 十八 parses as   tm_hour
                    18 in ja_JP locale
                    parses hour as a decimal number, 12 hour clock
             I      (range [01,12]), leading zeroes permitted but not tm_hour
                    required
                    parses hour from 12-hour clock using the
             OI     alternative numeric system, e.g. 六 reads as 06   tm_hour
                    in ja_JP locale
                    parses minute as a decimal number (range
             M      [00,59]), leading zeroes permitted but not        tm_min
                    required
             OM     parses minute using the alternative numeric       tm_min
                    system, e.g. 二十五 parses as 25 in ja_JP locale
                    parses second as a decimal number (range
             S      [00,60]), leading zeroes permitted but not        tm_sec
                    required
             OS     parses second using the alternative numeric       tm_sec
                    system, e.g. 二十四 parses as 24 in ja_JP locale
.SH Other
                    parses the locale's standard date and time string
             c      format, e.g. Sun Oct 17 04:41:13 2010 (locale     all
                    dependent)
                    parses the locale's alternative date and time
             Ec     string format, e.g. expecting 平成23年 (year      all
                    Heisei 23) instead of 2011年 (year 2011) in ja_JP
                    locale
             x      parses the locale's standard date representation  all
                    parses the locale's alternative date
             Ex     representation, e.g. expecting 平成23年 (year     all
                    Heisei 23) instead of 2011年 (year 2011) in ja_JP
                    locale
             X      parses the locale's standard time representation  all
             EX     parses the locale's alternative time              all
                    representation
             D      equivalent to "%m / %d / %y "                     tm_mon, tm_mday,
                                                                      tm_year
             r      parses locale's standard 12-hour clock time (in   tm_hour, tm_min,
                    POSIX, "%I : %M : %S %p")                         tm_sec
             R      equivalent to "%H : %M"                           tm_hour, tm_min
             T      equivalent to "%H : %M : %S"                      tm_hour, tm_min,
                                                                      tm_sec
             p      parses the locale's equivalent of a.m. or p.m.    tm_hour

         Note: tm_isdst is not written to, and needs to be set explicitly for use with
         functions such as mktime

.SH Return value

   An object of unspecified type such that

     * if in is an object of type std::basic_istream<CharT, Traits>, the expression in
       >> get_time(tmb, fmt)
          * has type std::basic_istream<CharT, Traits>&
          * has value in
          * behaves as if it called f(in, tmb, fmt)

   where the function f is defined as:

 template<class CharT, class Traits>
 void f(std::basic_ios<CharT, Traits>& str, std::tm* tmb, const CharT* fmt)
 {
     using Iter = std::istreambuf_iterator<CharT, Traits>;
     using TimeGet = time_get<CharT, Iter>;

     std::ios_base::iostate err = std::ios_base::goodbit;
     const TimeGet& tg = std::use_facet<TimeGet>(str.getloc());

     tg.get(Iter(str.rdbuf()), Iter(), str, err, tmb,
         fmt, fmt + Traits::length(fmt));

     if (err != std::ios_base::goodbit)
         str.setstate(err);
 }

.SH Notes

   As specified in std::time_get::do_get, which this function calls, it's unspecified
   if this function zero out the fields in *tmb that are not set directly by the
   conversion specifiers that appear in fmt: portable programs should initialize every
   field of *tmb to zero before calling std::get_time.

.SH Example

   Note: choose clang or gcc >= 12.1 to observe the output. libstdc++ before 12.1 does
   not correctly implement the %b specifier: bug #78714.


// Run this code

 #include <iomanip>
 #include <iostream>
 #include <locale>
 #include <sstream>

 int main()
 {
     std::tm t = {};
     std::istringstream ss("2011-Februar-18 23:12:34");
     ss.imbue(std::locale("de_DE.utf-8"));
     ss >> std::get_time(&t, "%Y-%b-%d %H:%M:%S");

     if (ss.fail())
         std::cout << "Parse failed\\n";
     else
         std::cout << std::put_time(&t, "%c") << '\\n';
 }

.SH Possible output:

 Sun Feb 18 23:12:34 2011

.SH See also

   time_get parses time/date values from an input character sequence into std::tm
            \fI(class template)\fP
   put_time formats and outputs a date/time value according to the specified format
   \fI(C++11)\fP  \fI(function template)\fP
   parse    parses a chrono object from a stream
   (C++20)  \fI(function template)\fP
